<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>6. Estructuras de datos &mdash; Tutorial de Python v2.6.2 documentation</title>
    <link rel="stylesheet" href="_static/default.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '#',
        VERSION:     '2.6.2',
        COLLAPSE_MODINDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="_static/jquery.js"></script>
    <script type="text/javascript" src="_static/doctools.js"></script>
    <link rel="top" title="Tutorial de Python v2.6.2 documentation" href="index.html" />
    <link rel="next" title="7. Módulos" href="modules.html" />
    <link rel="prev" title="5. Más herramientas para control de flujo" href="controlflow.html" /> 
  </head>
  <body>
    <div class="related">
      <h3>Navegación</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="Índice General"
             accesskey="I">índice</a></li>
        <li class="right" >
          <a href="modules.html" title="7. Módulos"
             accesskey="N">siguiente</a> |</li>
        <li class="right" >
          <a href="controlflow.html" title="5. Más herramientas para control de flujo"
             accesskey="P">anterior</a> |</li>
        <li><a href="contenido.html">Tutorial de Python v2.6.2 documentation</a> &raquo;</li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="estructuras-de-datos">
<span id="tut-structures"></span><h1>6. Estructuras de datos<a class="headerlink" href="#estructuras-de-datos" title="Enlazar permanentemente con este título">¶</a></h1>
<p>Este capítulo describe algunas cosas que ya aprendiste en más detalle,
y agrega algunas cosas nuevas también.</p>
<div class="section" id="mas-sobre-listas">
<span id="tut-morelists"></span><h2>6.1. Más sobre listas<a class="headerlink" href="#mas-sobre-listas" title="Enlazar permanentemente con este título">¶</a></h2>
<p>El tipo de dato lista tiene algunos métodos más.  Aquí están todos los métodos
de los objetos lista:</p>
<dl class="method">
<dt>
<tt class="descclassname">list.</tt><tt class="descname">append</tt><big>(</big><em>x</em><big>)</big></dt>
<dd>Agrega un ítem al final de la lista; equivale a <tt class="docutils literal"><span class="pre">a[len(a):]</span> <span class="pre">=</span> <span class="pre">[x]</span></tt>.</dd></dl>

<dl class="method">
<dt>
<tt class="descclassname">list.</tt><tt class="descname">extend</tt><big>(</big><em>L</em><big>)</big></dt>
<dd>Extiende la lista agregándole todos los ítems de la lista dada; equivale
a  <tt class="docutils literal"><span class="pre">a[len(a):]</span> <span class="pre">=</span> <span class="pre">L</span></tt>.</dd></dl>

<dl class="method">
<dt>
<tt class="descclassname">list.</tt><tt class="descname">insert</tt><big>(</big><em>i</em>, <em>x</em><big>)</big></dt>
<dd>Inserta un ítem en una posición dada.  El primer argumento es el índice
del ítem delante del cual se insertará, por lo tanto <tt class="docutils literal"><span class="pre">a.insert(0,</span> <span class="pre">x)</span></tt>
inserta al principio de la lista, y <tt class="docutils literal"><span class="pre">a.insert(len(a),</span> <span class="pre">x)</span></tt> equivale a
<tt class="docutils literal"><span class="pre">a.append(x)</span></tt>.</dd></dl>

<dl class="method">
<dt>
<tt class="descclassname">list.</tt><tt class="descname">remove</tt><big>(</big><em>x</em><big>)</big></dt>
<dd>Quita el primer ítem de la lista cuyo valor sea <em>x</em>. Es un error si no
existe tal ítem.</dd></dl>

<dl class="method">
<dt>
<tt class="descclassname">list.</tt><tt class="descname">pop</tt><big>(</big><span class="optional">[</span><em>i</em><span class="optional">]</span><big>)</big></dt>
<dd>Quita el ítem en la posición dada de la lista, y lo devuelve.  Si no se
especifica un índice, <tt class="docutils literal"><span class="pre">a.pop()</span></tt> quita y devuelve el último ítem de la
lista.  (Los corchetes que encierran a <em>i</em> en la firma del método denotan
que el parámetro es opcional, no que deberías escribir corchetes en esa
posición.  Verás esta notación con frecuencia en la Referencia de la
Biblioteca de Python.)</dd></dl>

<dl class="method">
<dt>
<tt class="descclassname">list.</tt><tt class="descname">index</tt><big>(</big><em>x</em><big>)</big></dt>
<dd>Devuelve el índice en la lista del primer ítem cuyo valor sea <em>x</em>. Es un
error si no existe tal ítem.</dd></dl>

<dl class="method">
<dt>
<tt class="descclassname">list.</tt><tt class="descname">count</tt><big>(</big><em>x</em><big>)</big></dt>
<dd>Devuelve el número de veces que <em>x</em> aparece en la lista.</dd></dl>

<dl class="method">
<dt>
<tt class="descclassname">list.</tt><tt class="descname">sort</tt><big>(</big><big>)</big></dt>
<dd>Ordena los ítems de la lista, in situ.</dd></dl>

<dl class="method">
<dt>
<tt class="descclassname">list.</tt><tt class="descname">reverse</tt><big>(</big><big>)</big></dt>
<dd>Invierte los elementos de la lista, in situ.</dd></dl>

<p>Un ejemplo que usa la mayoría de los métodos de lista:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="mf">66.25</span><span class="p">,</span> <span class="mi">333</span><span class="p">,</span> <span class="mi">333</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mf">1234.5</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">print</span> <span class="n">a</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="mi">333</span><span class="p">),</span> <span class="n">a</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="mf">66.25</span><span class="p">),</span> <span class="n">a</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s">&#39;x&#39;</span><span class="p">)</span>
<span class="go">2 1 0</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">333</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[66.25, 333, -1, 333, 1, 1234.5, 333]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="mi">333</span><span class="p">)</span>
<span class="go">1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="mi">333</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[66.25, -1, 333, 1, 1234.5, 333]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">reverse</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[333, 1234.5, 1, 333, -1, 66.25]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[-1, 1, 66.25, 333, 333, 1234.5]</span>
</pre></div>
</div>
<div class="section" id="usando-listas-como-pilas">
<span id="tut-lists-as-stacks"></span><h3>6.1.1. Usando listas como pilas<a class="headerlink" href="#usando-listas-como-pilas" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Los métodos de lista hacen que resulte muy fácil usar una lista como una pila,
donde el último elemento añadido es el primer elemento retirado (&#8220;último en
entrar, primero en salir&#8221;).  Para agregar un ítem a la cima de la pila, use
<tt class="xref docutils literal"><span class="pre">append()</span></tt>. Para retirar un ítem de la cima de la pila, use <tt class="xref docutils literal"><span class="pre">pop()</span></tt>
sin un índice explícito.  Por ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">stack</span> <span class="o">=</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">stack</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">6</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">stack</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">stack</span>
<span class="go">[3, 4, 5, 6, 7]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">stack</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
<span class="go">7</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">stack</span>
<span class="go">[3, 4, 5, 6]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">stack</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
<span class="go">6</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">stack</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
<span class="go">5</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">stack</span>
<span class="go">[3, 4]</span>
</pre></div>
</div>
</div>
<div class="section" id="usando-listas-como-colas">
<span id="tut-lists-as-queues"></span><h3>6.1.2. Usando listas como colas<a class="headerlink" href="#usando-listas-como-colas" title="Enlazar permanentemente con este título">¶</a></h3>
<p>También puedes usar una lista convenientemente como una cola, donde el primer
elemento añadido es el primer elemento retirado (&#8220;primero en entrar, primero
en salir&#8221;).  Para agregar un ítem al final de la cola, use <tt class="xref docutils literal"><span class="pre">append()</span></tt>.
Para retirar un ítem del frente de la pila, use <tt class="xref docutils literal"><span class="pre">pop()</span></tt> con <tt class="docutils literal"><span class="pre">0</span></tt> como
índice. Por ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">queue</span> <span class="o">=</span> <span class="p">[</span><span class="s">&quot;Eric&quot;</span><span class="p">,</span> <span class="s">&quot;John&quot;</span><span class="p">,</span> <span class="s">&quot;Michael&quot;</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">queue</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s">&quot;Terry&quot;</span><span class="p">)</span>           <span class="c"># llega Terry</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">queue</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s">&quot;Graham&quot;</span><span class="p">)</span>          <span class="c"># llega Graham</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">queue</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">&#39;Eric&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">queue</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">&#39;John&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">queue</span>
<span class="go">[&#39;Michael&#39;, &#39;Terry&#39;, &#39;Graham&#39;]</span>
</pre></div>
</div>
</div>
<div class="section" id="herramientas-de-programacion-funcional">
<span id="tut-functional"></span><h3>6.1.3. Herramientas de programación funcional<a class="headerlink" href="#herramientas-de-programacion-funcional" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Hay tres funciones integradas que son muy útiles cuando se usan con listas:
<tt class="xref docutils literal"><span class="pre">filter()</span></tt>, <tt class="xref docutils literal"><span class="pre">map()</span></tt>, y <tt class="xref docutils literal"><span class="pre">reduce()</span></tt>.</p>
<p><tt class="docutils literal"><span class="pre">filter(funcion,</span> <span class="pre">secuencia)</span></tt> devuelve una secuencia con aquellos ítems de la
secuencia para los cuales <tt class="docutils literal"><span class="pre">funcion(item)</span></tt> es verdadero. Si <em>secuencia</em> es un
<tt class="xref docutils literal"><span class="pre">string</span></tt> o <tt class="xref docutils literal"><span class="pre">tuple</span></tt>, el resultado será del mismo tipo;
de otra manera, siempre será <tt class="xref docutils literal"><span class="pre">list</span></tt>.  Por ejemplo, para calcular unos
números primos:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">):</span> <span class="k">return</span> <span class="n">x</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">!=</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">x</span> <span class="o">%</span> <span class="mi">3</span> <span class="o">!=</span> <span class="mi">0</span>
<span class="gp">...</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">filter</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="nb">range</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">25</span><span class="p">))</span>
<span class="go">[5, 7, 11, 13, 17, 19, 23]</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">map(funcion,</span> <span class="pre">secuencia)</span></tt> llama a <tt class="docutils literal"><span class="pre">funcion(item)</span></tt> por cada uno de los
ítems de la secuencia y devuelve una lista de los valores retornados.  Por
ejemplo, para calcular unos cubos:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">cubo</span><span class="p">(</span><span class="n">x</span><span class="p">):</span> <span class="k">return</span> <span class="n">x</span><span class="o">*</span><span class="n">x</span><span class="o">*</span><span class="n">x</span>
<span class="gp">...</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">map</span><span class="p">(</span><span class="n">cubo</span><span class="p">,</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">11</span><span class="p">))</span>
<span class="go">[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]</span>
</pre></div>
</div>
<p>Se puede pasar más de una secuencia; la función debe entonces tener tantos
argumentos como secuencias haya y es llamada con el ítem correspondiente de
cada secuencia (o <tt class="xref docutils literal"><span class="pre">None</span></tt> si alguna secuencia es más corta que otra).  Por
ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">sec</span> <span class="o">=</span> <span class="nb">range</span><span class="p">(</span><span class="mi">8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">):</span> <span class="k">return</span> <span class="n">x</span><span class="o">+</span><span class="n">y</span>
<span class="gp">...</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">map</span><span class="p">(</span><span class="n">add</span><span class="p">,</span> <span class="n">sec</span><span class="p">,</span> <span class="n">sec</span><span class="p">)</span>
<span class="go">[0, 2, 4, 6, 8, 10, 12, 14]</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">reduce(funcion,</span> <span class="pre">secuencia)</span></tt> devuelve un único valor que se construye
llamando a la función binaria <em>funcion</em> con los primeros dos ítems de la
secuencia, entonces con el resultado y el siguiente ítem, y así sucesivamente.
Por ejemplo, para calcular la suma de los números de 1 a 10:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">sumar</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">y</span><span class="p">):</span> <span class="k">return</span> <span class="n">x</span><span class="o">+</span><span class="n">y</span>
<span class="gp">...</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">reduce</span><span class="p">(</span><span class="n">sumar</span><span class="p">,</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">11</span><span class="p">))</span>
<span class="go">55</span>
</pre></div>
</div>
<p>Si sólo hay un ítem en la secuencia, se devuelve su valor; si la secuencia
está vacía, se lanza una excepción.</p>
<p>Un tercer argumento puede pasarse para indicar el valor inicial.  En este caso
el valor inicial se devuelve para una secuencia vacía, y la función se aplica
primero al valor inicial y el primer ítem de la secuencia, entonces al
resultado y al siguiente ítem, y así sucesivamente. Por ejemplo,</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">sum</span><span class="p">(</span><span class="n">sec</span><span class="p">):</span>
<span class="gp">... </span>    <span class="k">def</span> <span class="nf">sumar</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">y</span><span class="p">):</span> <span class="k">return</span> <span class="n">x</span><span class="o">+</span><span class="n">y</span>
<span class="gp">... </span>    <span class="k">return</span> <span class="nb">reduce</span><span class="p">(</span><span class="n">sumar</span><span class="p">,</span> <span class="n">sec</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="gp">...</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">sum</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">11</span><span class="p">))</span>
<span class="go">55</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">sum</span><span class="p">([])</span>
<span class="go">0</span>
</pre></div>
</div>
<p>No uses la definición de este ejemplo de <tt class="xref docutils literal"><span class="pre">sum()</span></tt>: ya que la sumatoria es
una necesidad tan común, se provee una función integrada <tt class="docutils literal"><span class="pre">sum(secuencia)</span></tt>
que funciona exactamente así.</p>
<p>
<span class="versionmodified">Nuevo en la versión 2.3.</span></p>
</div>
<div class="section" id="listas-por-comprension">
<h3>6.1.4. Listas por comprensión<a class="headerlink" href="#listas-por-comprension" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Las listas por comprensión proveen una forma concisa de crear listas sin tener
que recurrir al uso de <tt class="xref docutils literal"><span class="pre">map()</span></tt>, <tt class="xref docutils literal"><span class="pre">filter()</span></tt> y/o <tt class="xref docutils literal"><span class="pre">lambda</span></tt>.  La
definición resultante de la lista a menudo tiende a ser más clara que las
listas formadas usando esas construcciones.</p>
<p>Cada lista por comprensión consiste de una expresión seguida por una cláusula
<tt class="xref docutils literal"><span class="pre">for</span></tt>, luego cero o más cláusulas <tt class="xref docutils literal"><span class="pre">for</span></tt> o <tt class="xref docutils literal"><span class="pre">if</span></tt>. El
resultado será una lista que resulta de evaluar la expresión en el contexto de
las cláusulas <tt class="xref docutils literal"><span class="pre">for</span></tt> y <tt class="xref docutils literal"><span class="pre">if</span></tt> que sigan.  Si la expresión
evalua a una tupla, debe encerrarse entre paréntesis.</p>
<div class="highlight-python"><pre>&gt;&gt;&gt; frutafresca = ['  banana', '  mora de Logan ', 'maracuya  ']
&gt;&gt;&gt; [arma.strip() for arma in frutafresca]
['banana', 'mora de Logan', 'maracuya']
&gt;&gt;&gt; vec = [2, 4, 6]
&gt;&gt;&gt; [3*x for x in vec]
[6, 12, 18]
&gt;&gt;&gt; [3*x for x in vec if x &gt; 3]
[12, 18]
&gt;&gt;&gt; [3*x for x in vec if x &lt; 2]
[]
&gt;&gt;&gt; [[x,x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
&gt;&gt;&gt; [x, x**2 for x in vec]   # error - se requieren paréntesis para tuplas
Traceback (most recent call last):
...
  [x, x**2 for x in vec]
             ^
SyntaxError: invalid syntax
&gt;&gt;&gt; [(x, x**2) for x in vec]
[(2, 4), (4, 16), (6, 36)]
&gt;&gt;&gt; vec1 = [2, 4, 6]
&gt;&gt;&gt; vec2 = [4, 3, -9]
&gt;&gt;&gt; [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
&gt;&gt;&gt; [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
&gt;&gt;&gt; [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]</pre>
</div>
<p>Las listas por comprensión son mucho más flexibles que <tt class="xref docutils literal"><span class="pre">map()</span></tt> y pueden
aplicarse a expresiones complejas y funciones anidadas:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="p">[</span><span class="nb">str</span><span class="p">(</span><span class="nb">round</span><span class="p">(</span><span class="mi">355</span><span class="o">/</span><span class="mf">113.0</span><span class="p">,</span> <span class="n">i</span><span class="p">))</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">6</span><span class="p">)]</span>
<span class="go">[&#39;3.1&#39;, &#39;3.14&#39;, &#39;3.142&#39;, &#39;3.1416&#39;, &#39;3.14159&#39;]</span>
</pre></div>
</div>
</div>
<div class="section" id="listas-por-comprension-anidadas">
<h3>6.1.5. Listas por comprensión anidadas<a class="headerlink" href="#listas-por-comprension-anidadas" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Si tienes el estómago suficiente, las listas por comprensión pueden anidarse.
Son una herramienta poderosa pero, como toda herramienta poderosa, deben
usarse con cuidado, o ni siquiera usarse.</p>
<p>Considera el siguiente ejemplo de una matriz de 3x3 como una lista que
contiene tres listas, una por fila:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">mat</span> <span class="o">=</span> <span class="p">[</span>
<span class="gp">... </span>       <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span>
<span class="gp">... </span>       <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">],</span>
<span class="gp">... </span>       <span class="p">[</span><span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">9</span><span class="p">],</span>
<span class="gp">... </span>      <span class="p">]</span>
</pre></div>
</div>
<p>Ahora, si quisieras intercambiar filas y columnas, podrías usar una lista por
comprensión:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="k">print</span> <span class="p">[[</span><span class="n">fila</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="k">for</span> <span class="n">fila</span> <span class="ow">in</span> <span class="n">mat</span><span class="p">]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">]]</span>
<span class="go">[[1, 4, 7], [2, 5, 8], [3, 6, 9]]</span>
</pre></div>
</div>
<p>Se debe tener cuidado especial para la lista por comprensión <em>anidada</em>:</p>
<blockquote>
Para evitar aprensión cuando se anidan lista por comprensión, lee de
derecha a izquierda.</blockquote>
<p>Una versión más detallada de este retazo de código muestra el flujo de manera
explícita:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">]:</span>
    <span class="k">for</span> <span class="n">fila</span> <span class="ow">in</span> <span class="n">mat</span><span class="p">:</span>
        <span class="k">print</span> <span class="n">fila</span><span class="p">[</span><span class="n">i</span><span class="p">],</span>
    <span class="k">print</span>
</pre></div>
</div>
<p>En el mundo real, deberías preferir funciones predefinidas a declaraciones con
flujo complejo.  La función <tt class="xref docutils literal"><span class="pre">zip()</span></tt> haría un buen trabajo para este caso de
uso:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="nb">zip</span><span class="p">(</span><span class="o">*</span><span class="n">mat</span><span class="p">)</span>
<span class="go">[(1, 4, 7), (2, 5, 8), (3, 6, 9)]</span>
</pre></div>
</div>
<p>Ver <a class="reference external" href="controlflow.html#tut-unpacking-arguments"><em>Desempaquetando una lista de argumentos</em></a> para detalles en el asterisco de esta línea.</p>
</div>
</div>
<div class="section" id="la-instruccion-del">
<span id="tut-del"></span><h2>6.2. La instrucción <tt class="xref docutils literal"><span class="pre">del</span></tt><a class="headerlink" href="#la-instruccion-del" title="Enlazar permanentemente con este título">¶</a></h2>
<p>Hay una manera de quitar un ítem de una lista dado su índice en lugar de su
valor: la instrucción <tt class="xref docutils literal"><span class="pre">del</span></tt>.  Esta es diferente del método
<tt class="xref docutils literal"><span class="pre">pop()</span></tt>, el cual devuelve un valor.  La instrucción <tt class="xref docutils literal"><span class="pre">del</span></tt> también
puede usarse para quitar secciones de una lista o vaciar la lista completa (lo
que hacíamos antes asignando una lista vacía a la sección).  Por ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mf">66.25</span><span class="p">,</span> <span class="mi">333</span><span class="p">,</span> <span class="mi">333</span><span class="p">,</span> <span class="mf">1234.5</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">del</span> <span class="n">a</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[1, 66.25, 333, 333, 1234.5]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">del</span> <span class="n">a</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">4</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[1, 66.25, 1234.5]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">del</span> <span class="n">a</span><span class="p">[:]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">[]</span>
</pre></div>
</div>
<p><tt class="xref docutils literal"><span class="pre">del</span></tt> puede usarse también para eliminar variables:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="k">del</span> <span class="n">a</span>
</pre></div>
</div>
<p>Hacer referencia al nombre <tt class="docutils literal"><span class="pre">a</span></tt> de aquí en más es un error (al menos hasta que
se le asigne otro valor).  Veremos otros usos para <tt class="xref docutils literal"><span class="pre">del</span></tt> más adelante.</p>
</div>
<div class="section" id="tuplas-y-secuencias">
<span id="tut-tuples"></span><h2>6.3. Tuplas y secuencias<a class="headerlink" href="#tuplas-y-secuencias" title="Enlazar permanentemente con este título">¶</a></h2>
<p>Vimos que las listas y cadenas tienen propiedades en común, como el indizado y
las operaciones de seccionado.  Estas son dos ejemplos de datos de tipo
<em>secuencia</em> (ver <em class="xref">typesseq</em>).  Como Python es un lenguaje en evolución,
otros datos de tipo secuencia pueden agregarse.  Existe otro dato de tipo
secuencia estándar: la <em>tupla</em>.</p>
<p>Una tupla consiste de un número de valores separados por comas, por ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">t</span> <span class="o">=</span> <span class="mi">12345</span><span class="p">,</span> <span class="mi">54321</span><span class="p">,</span> <span class="s">&#39;hola!&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="go">12345</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span>
<span class="go">(12345, 54321, &#39;hola!&#39;)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c"># Las tuplas pueden anidarse:</span>
<span class="gp">... </span><span class="n">u</span> <span class="o">=</span> <span class="n">t</span><span class="p">,</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">u</span>
<span class="go">((12345, 54321, &#39;hola!&#39;), (1, 2, 3, 4, 5))</span>
</pre></div>
</div>
<p>Como puedes ver, en la salida las tuplas siempre se encierran entre paréntesis,
para que las tuplas anidadas puedan interpretarse correctamente; pueden
ingresarse con o sin paréntesis, aunque a menudo los paréntesis son necesarios
de todas formas (si la tupla es parte de una expresión más grande).</p>
<p>Las tuplas tienen muchos usos.  Por ejemplo: pares ordenados (x, y), registros
de empleados de una base de datos, etc.  Las tuplas, al igual que las cadenas,
son inmutables: no es posible asignar a los ítems individuales de una tupla
(aunque puedes simular bastante ese efecto mediante seccionado y
concatenación).  También es posible crear tuplas que contengan objetos mutables
como listas.</p>
<p>Un problema particular es la construcción de tuplas que contengan 0 o 1 ítem:
la sintaxis presenta algunas peculiaridades para estos casos.  Las tuplas
vacías se construyen mediante un par de paréntesis vacío; una tupla con un ítem
se construye poniendo una coma a continuación del valor (no alcanza con
encerrar un único valor entre paréntesis).  Feo, pero efectivo.  Por ejemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">vacia</span> <span class="o">=</span> <span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">singleton</span> <span class="o">=</span> <span class="s">&#39;hola&#39;</span><span class="p">,</span>    <span class="c"># &lt;-- notar la coma al final</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">len</span><span class="p">(</span><span class="n">vacia</span><span class="p">)</span>
<span class="go">0</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">len</span><span class="p">(</span><span class="n">singleton</span><span class="p">)</span>
<span class="go">1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">singleton</span>
<span class="go">(&#39;hola&#39;,)</span>
</pre></div>
</div>
<p>La declaración <tt class="docutils literal"><span class="pre">t</span> <span class="pre">=</span> <span class="pre">12345,</span> <span class="pre">54321,</span> <span class="pre">'hola!'</span></tt> es un ejemplo de <em>empaquetado de
tuplas</em>: los valores <tt class="docutils literal"><span class="pre">12345</span></tt>, <tt class="docutils literal"><span class="pre">54321</span></tt> y <tt class="docutils literal"><span class="pre">'hola!'</span></tt> se empaquetan juntos en
una tupla.</p>
<p>La operación inversa también es posible:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">z</span> <span class="o">=</span> <span class="n">t</span>
</pre></div>
</div>
<p>Esto se llama, apropiadamente, <em>desempaquetado de secuencias</em>, y funciona para
cualquier secuencia en el lado derecho del igual.  El desempaquetado de
secuencias requiere que la lista de variables a la izquierda
tenga el mismo número de elementos que el tamaño de la secuencia.  Notá que
la asignación múltiple es en realidad sólo una combinación de empaquetado de
tuplas y desempaquetado de secuencias.</p>
</div>
<div class="section" id="conjuntos">
<span id="tut-sets"></span><h2>6.4. Conjuntos<a class="headerlink" href="#conjuntos" title="Enlazar permanentemente con este título">¶</a></h2>
<p>Python también incluye un tipo de dato para <em>conjuntos</em>.  Un conjunto es una
colección no ordenada y sin elementos repetidos.  Los usos básicos de éstos
incluyen verificación de pertenencia y eliminación de entradas duplicadas.
Los conjuntos también soportan operaciones matemáticas como la unión,
intersección, diferencia, y diferencia simétrica.</p>
<p>Una pequeña demostración:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">canasta</span> <span class="o">=</span> <span class="p">[</span><span class="s">&#39;manzana&#39;</span><span class="p">,</span> <span class="s">&#39;naranja&#39;</span><span class="p">,</span> <span class="s">&#39;manzana&#39;</span><span class="p">,</span> <span class="s">&#39;pera&#39;</span><span class="p">,</span> <span class="s">&#39;naranja&#39;</span><span class="p">,</span> <span class="s">&#39;banana&#39;</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">fruta</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="n">canasta</span><span class="p">)</span>               <span class="c"># crea un conjunto sin repetidos</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">fruta</span>
<span class="go">set([&#39;pera&#39;, &#39;manzana&#39;, &#39;banana&#39;, &#39;naranja&#39;])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;naranja&#39;</span> <span class="ow">in</span> <span class="n">fruta</span>                 <span class="c"># verificación de pertenencia rápida</span>
<span class="go">True</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;yerba&#39;</span> <span class="ow">in</span> <span class="n">fruta</span>
<span class="go">False</span>

<span class="gp">&gt;&gt;&gt; </span><span class="c"># veamos las operaciones para las letras únicas de dos palabras</span>
<span class="gp">...</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="s">&#39;abracadabra&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="s">&#39;alacazam&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>                                  <span class="c"># letras únicas en a</span>
<span class="go">set([&#39;a&#39;, &#39;r&#39;, &#39;b&#39;, &#39;c&#39;, &#39;d&#39;])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">-</span> <span class="n">b</span>                              <span class="c"># letras en a pero no en b</span>
<span class="go">set([&#39;r&#39;, &#39;b&#39;, &#39;d&#39;])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">|</span> <span class="n">b</span>                              <span class="c"># letras en a o en b</span>
<span class="go">set([&#39;a&#39;, &#39;c&#39;, &#39;b&#39;, &#39;d&#39;, &#39;m&#39;, &#39;l&#39;, &#39;r&#39;, &#39;z&#39;])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">&amp;</span> <span class="n">b</span>                              <span class="c"># letras en a y en b</span>
<span class="go">set([&#39;a&#39;, &#39;c&#39;])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">^</span> <span class="n">b</span>                              <span class="c"># letras en a o b pero no en ambos</span>
<span class="go">set([&#39;b&#39;, &#39;d&#39;, &#39;m&#39;, &#39;l&#39;, &#39;r&#39;, &#39;z&#39;])</span>
</pre></div>
</div>
</div>
<div class="section" id="diccionarios">
<span id="tut-dictionaries"></span><h2>6.5. Diccionarios<a class="headerlink" href="#diccionarios" title="Enlazar permanentemente con este título">¶</a></h2>
<p>Otro tipo de dato útil incluído en Python es el <em>diccionario</em> (ver
<em class="xref">typesmapping</em>).  Los diccionarios se encuentran a veces en otros
lenguajes como &#8220;memorias asociativas&#8221; o &#8220;arreglos asociativos&#8221;.  A diferencia
de las secuencias, que se indexan mediante un rango numérico, los diccionarios
se indexan con <em>claves</em>, que pueden ser cualquier tipo inmutable; las cadenas y
números siempre pueden ser claves.  Las tuplas pueden usarse como claves si
solamente contienen cadenas, números o tuplas; si una tupla contiene cualquier
objeto mutable directa o indirectamente, no puede usarse como clave.
No podés usar listas como claves, ya que las listas pueden modificarse usando
asignación por índice, asignación por sección, o métodos como <tt class="xref docutils literal"><span class="pre">append()</span></tt> y
<tt class="xref docutils literal"><span class="pre">extend()</span></tt>.</p>
<p>Lo mejor es pensar en un diccionario como un conjunto no ordenado de pares
<em>clave: valor</em>, con el requerimiento de que las claves sean únicas (dentro de
un diccionario en particular).  Un par de llaves crean un diccionario vacío:
<tt class="docutils literal"><span class="pre">{}</span></tt>.  Colocar una lista de pares clave:valor separados por comas entre las
llaves añade pares clave:valor iniciales al diccionario; esta también es la
forma en que los diccionarios se presentan en la salida.</p>
<p>Las operaciones principales sobre un diccionario son guardar un valor con una
clave y extraer ese valor dada la clave.  También es posible borrar un par
clave:valor con <tt class="docutils literal"><span class="pre">del</span></tt>.  Si usás una clave que ya está en uso para guardar un
valor, el valor que estaba asociado con esa clave se pierde.  Es un error
extraer un valor usando una clave no existente.</p>
<p>El método <tt class="xref docutils literal"><span class="pre">keys()</span></tt> de un diccionario devuelve una lista de todas las claves
en uso de ese diccionario, en un orden arbitrario (si la querés ordenada,
simplemente usá el metodo <tt class="xref docutils literal"><span class="pre">sort()</span></tt> sobre la lista de claves).  Para
verificar si una clave está en el diccionario, utilizá la palabra clave
<tt class="xref docutils literal"><span class="pre">in</span></tt>.</p>
<p>Un pequeño ejemplo de uso de un diccionario:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">tel</span> <span class="o">=</span> <span class="p">{</span><span class="s">&#39;jack&#39;</span><span class="p">:</span> <span class="mi">4098</span><span class="p">,</span> <span class="s">&#39;sape&#39;</span><span class="p">:</span> <span class="mi">4139</span><span class="p">}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tel</span><span class="p">[</span><span class="s">&#39;guido&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="mi">4127</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tel</span>
<span class="go">{&#39;sape&#39;: 4139, &#39;jack&#39;: 4098, &#39;guido&#39;: 4127}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tel</span><span class="p">[</span><span class="s">&#39;jack&#39;</span><span class="p">]</span>
<span class="go">4098</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">del</span> <span class="n">tel</span><span class="p">[</span><span class="s">&#39;sape&#39;</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tel</span><span class="p">[</span><span class="s">&#39;irv&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="mi">4127</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tel</span>
<span class="go">{&#39;jack&#39;: 4098, &#39;irv&#39;: 4127, &#39;guido&#39;: 4127}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tel</span><span class="o">.</span><span class="n">keys</span><span class="p">()</span>
<span class="go">[&#39;jack&#39;, &#39;irv&#39;, &#39;guido&#39;]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="s">&#39;guido&#39;</span> <span class="ow">in</span> <span class="n">tel</span>
<span class="go">True</span>
</pre></div>
</div>
<p>El constructor <tt class="xref docutils literal"><span class="pre">dict()</span></tt> crea un diccionario directamente desde listas de
pares clave-valor guardados como tuplas.  Cuando los pares siguen un patrón,
se puede especificar de forma compacta la lista de pares clave-valor por
comprensión.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="nb">dict</span><span class="p">([(</span><span class="s">&#39;sape&#39;</span><span class="p">,</span> <span class="mi">4139</span><span class="p">),</span> <span class="p">(</span><span class="s">&#39;guido&#39;</span><span class="p">,</span> <span class="mi">4127</span><span class="p">),</span> <span class="p">(</span><span class="s">&#39;jack&#39;</span><span class="p">,</span> <span class="mi">4098</span><span class="p">)])</span>
<span class="go">{&#39;sape&#39;: 4139, &#39;jack&#39;: 4098, &#39;guido&#39;: 4127}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">dict</span><span class="p">([(</span><span class="n">x</span><span class="p">,</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">6</span><span class="p">)])</span>     <span class="c"># use a list comprehension</span>
<span class="go">{2: 4, 4: 16, 6: 36}</span>
</pre></div>
</div>
<p>Más adelante en este tutorial, aprenderemos acerca de Expresiones Generadoras
que están mejor preparadas para la tarea de proveer pares clave-valor al
constructor <tt class="xref docutils literal"><span class="pre">dict()</span></tt>.</p>
<p>Cuando las claves son cadenas simples, a veces resulta más fácil especificar
los pares usando argumentos por palabra clave:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="nb">dict</span><span class="p">(</span><span class="n">sape</span><span class="o">=</span><span class="mi">4139</span><span class="p">,</span> <span class="n">guido</span><span class="o">=</span><span class="mi">4127</span><span class="p">,</span> <span class="n">jack</span><span class="o">=</span><span class="mi">4098</span><span class="p">)</span>
<span class="go">{&#39;sape&#39;: 4139, &#39;jack&#39;: 4098, &#39;guido&#39;: 4127}</span>
</pre></div>
</div>
</div>
<div class="section" id="tecnicas-de-iteracion">
<span id="tut-loopidioms"></span><h2>6.6. Técnicas de iteración<a class="headerlink" href="#tecnicas-de-iteracion" title="Enlazar permanentemente con este título">¶</a></h2>
<p>Cuando iteramos sobre diccionarios, se pueden obtener al mismo tiempo la clave
y su valor correspondiente usando el método <tt class="xref docutils literal"><span class="pre">iteritems()</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">caballeros</span> <span class="o">=</span> <span class="p">{</span><span class="s">&#39;gallahad&#39;</span><span class="p">:</span> <span class="s">&#39;el puro&#39;</span><span class="p">,</span> <span class="s">&#39;robin&#39;</span><span class="p">:</span> <span class="s">&#39;el valiente&#39;</span><span class="p">}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">caballeros</span><span class="o">.</span><span class="n">iteritems</span><span class="p">():</span>
<span class="gp">... </span>    <span class="k">print</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span>
<span class="gp">...</span>
<span class="go">gallahad el puro</span>
<span class="go">robin el valiente</span>
</pre></div>
</div>
<p>Cuando se itera sobre una secuencia, se puede obtener el índice de posición
junto a su valor correspondiente usando la función <tt class="xref docutils literal"><span class="pre">enumerate()</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">([</span><span class="s">&#39;ta&#39;</span><span class="p">,</span> <span class="s">&#39;te&#39;</span><span class="p">,</span> <span class="s">&#39;ti&#39;</span><span class="p">]):</span>
<span class="gp">... </span>    <span class="k">print</span> <span class="n">i</span><span class="p">,</span> <span class="n">v</span>
<span class="gp">...</span>
<span class="go">0 ta</span>
<span class="go">1 te</span>
<span class="go">2 ti</span>
</pre></div>
</div>
<p>Para iterar sobre dos o más secuencias al mismo tiempo, los valores pueden
emparejarse con la función <tt class="xref docutils literal"><span class="pre">zip()</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">preguntas</span> <span class="o">=</span> <span class="p">[</span><span class="s">&#39;nombre&#39;</span><span class="p">,</span> <span class="s">&#39;objetivo&#39;</span><span class="p">,</span> <span class="s">&#39;color favorito&#39;</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">respuestas</span> <span class="o">=</span> <span class="p">[</span><span class="s">&#39;lancelot&#39;</span><span class="p">,</span> <span class="s">&#39;el santo grial&#39;</span><span class="p">,</span> <span class="s">&#39;azul&#39;</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">p</span><span class="p">,</span> <span class="n">r</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">preguntas</span><span class="p">,</span> <span class="n">respuestas</span><span class="p">):</span>
<span class="gp">... </span>    <span class="k">print</span> <span class="s">&#39;Cual es tu {0}?  {1}.&#39;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">r</span><span class="p">)</span>
<span class="gp">...</span>
<span class="go">Cual es tu nombre?  lancelot.</span>
<span class="go">Cual es tu objetivo?  el santo grial.</span>
<span class="go">Cual es tu color favorito?  azul.</span>
</pre></div>
</div>
<p>Para iterar sobre una secuencia en orden inverso, se especifica primero la
secuencia al derecho y luego se llama a la función <tt class="xref docutils literal"><span class="pre">reversed()</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="nb">xrange</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">10</span><span class="p">,</span><span class="mi">2</span><span class="p">)):</span>
<span class="gp">... </span>    <span class="k">print</span> <span class="n">i</span>
<span class="gp">...</span>
<span class="go">9</span>
<span class="go">7</span>
<span class="go">5</span>
<span class="go">3</span>
<span class="go">1</span>
</pre></div>
</div>
<p>Para iterar sobre una secuencia ordenada, se utiliza la función <tt class="xref docutils literal"><span class="pre">sorted()</span></tt>
la cual devuelve una nueva lista ordenada dejando a la original intacta.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">canasta</span> <span class="o">=</span> <span class="p">[</span><span class="s">&#39;manzana&#39;</span><span class="p">,</span> <span class="s">&#39;naranja&#39;</span><span class="p">,</span> <span class="s">&#39;manzana&#39;</span><span class="p">,</span> <span class="s">&#39;pera&#39;</span><span class="p">,</span> <span class="s">&#39;naranja&#39;</span><span class="p">,</span> <span class="s">&#39;banana&#39;</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">f</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="n">canasta</span><span class="p">)):</span>
<span class="gp">... </span>    <span class="k">print</span> <span class="n">f</span>
<span class="gp">...</span>
<span class="go">banana</span>
<span class="go">manzana</span>
<span class="go">naranja</span>
<span class="go">pera</span>
</pre></div>
</div>
</div>
<div class="section" id="mas-acerca-de-condiciones">
<span id="tut-conditions"></span><h2>6.7. Más acerca de condiciones<a class="headerlink" href="#mas-acerca-de-condiciones" title="Enlazar permanentemente con este título">¶</a></h2>
<p>Las condiciones usadas en las instrucciones <tt class="docutils literal"><span class="pre">while</span></tt> e <tt class="docutils literal"><span class="pre">if</span></tt> pueden contener
cualquier operador, no sólo comparaciones.</p>
<p>Los operadores de comparación <tt class="docutils literal"><span class="pre">in</span></tt> y <tt class="docutils literal"><span class="pre">not</span> <span class="pre">in</span></tt> verifican si un valor está
(o no está) en una secuencia. Los operadores <tt class="docutils literal"><span class="pre">is</span></tt> e <tt class="docutils literal"><span class="pre">is</span> <span class="pre">not</span></tt> comparan si
dos objetos son realmente el mismo objeto; esto es significativo sólo para
objetos mutables como las listas.  Todos los operadores de comparación tienen
la misma prioridad, la cual es menor que la de todos los operadores numéricos.</p>
<p>Las comparaciones pueden encadenarse.  Por ejemplo, <tt class="docutils literal"><span class="pre">a</span> <span class="pre">&lt;</span> <span class="pre">b</span> <span class="pre">==</span> <span class="pre">c</span></tt> verifica si
<tt class="docutils literal"><span class="pre">a</span></tt> es menor que <tt class="docutils literal"><span class="pre">b</span></tt> y además si <tt class="docutils literal"><span class="pre">b</span></tt> es igual a <tt class="docutils literal"><span class="pre">c</span></tt>.</p>
<p>Las comparaciones pueden combinarse mediante los operadores booleanos <tt class="docutils literal"><span class="pre">and</span></tt> y
<tt class="docutils literal"><span class="pre">or</span></tt>, y el resultado de una comparación (o de cualquier otra expresión
booleana) puede negarse con <tt class="docutils literal"><span class="pre">not</span></tt>.  Estos tienen prioridades menores que los
operadores de comparación; entre ellos <tt class="docutils literal"><span class="pre">not</span></tt> tiene la mayor prioridad y
<tt class="docutils literal"><span class="pre">or</span></tt> la menor, o sea que <tt class="docutils literal"><span class="pre">A</span> <span class="pre">and</span> <span class="pre">not</span> <span class="pre">B</span> <span class="pre">or</span> <span class="pre">C</span></tt> equivale a
<tt class="docutils literal"><span class="pre">(A</span> <span class="pre">and</span> <span class="pre">(not</span> <span class="pre">B))</span> <span class="pre">or</span> <span class="pre">C</span></tt>.  Como siempre, los paréntesis pueden usarse para
expresar la composición deseada.</p>
<p>Los operadores booleanos <tt class="docutils literal"><span class="pre">and</span></tt> y <tt class="docutils literal"><span class="pre">or</span></tt> son los llamados operadores
<em>cortocircuito</em>: sus argumentos se evalúan de izquierda a derecha, y la
evaluación se detiene en el momento en que se determina su resultado.  Por
ejemplo, si <tt class="docutils literal"><span class="pre">A</span></tt> y <tt class="docutils literal"><span class="pre">C</span></tt> son verdaderas pero <tt class="docutils literal"><span class="pre">B</span></tt> es falsa, en
<tt class="docutils literal"><span class="pre">A</span> <span class="pre">and</span> <span class="pre">B</span> <span class="pre">and</span> <span class="pre">C</span></tt> no se evalúa la expresión <tt class="docutils literal"><span class="pre">C</span></tt>.  Cuando se usa como un valor
general y no como un booleano, el valor devuelto de un operador cortocircuito
es el último argumento evaluado.</p>
<p>Es posible asignar el resultado de una comparación u otra expresión booleana a
una variable.  Por ejemplo,</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">cadena1</span><span class="p">,</span> <span class="n">cadena2</span><span class="p">,</span> <span class="n">cadena3</span> <span class="o">=</span> <span class="s">&#39;&#39;</span><span class="p">,</span> <span class="s">&#39;Trondheim&#39;</span><span class="p">,</span> <span class="s">&#39;Paso Hammer&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">non_nulo</span> <span class="o">=</span> <span class="n">cadena1</span> <span class="ow">or</span> <span class="n">cadena2</span> <span class="ow">or</span> <span class="n">cadena3</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">non_nulo</span>
<span class="go">&#39;Trondheim&#39;</span>
</pre></div>
</div>
<p>Notá que en Python, a diferencia de C, la asignación no puede ocurrir dentro de
expresiones.  Los programadores de C pueden renegar por esto, pero es algo que
evita un tipo de problema común encontrado en programas en C: escribir <tt class="docutils literal"><span class="pre">=</span></tt> en
una expresión cuando lo que se quiere escribir es <tt class="docutils literal"><span class="pre">==</span></tt>.</p>
</div>
<div class="section" id="comparando-secuencias-y-otros-tipos">
<span id="tut-comparing"></span><h2>6.8. Comparando secuencias y otros tipos<a class="headerlink" href="#comparando-secuencias-y-otros-tipos" title="Enlazar permanentemente con este título">¶</a></h2>
<p>Las secuencias pueden compararse con otros objetos del mismo tipo de secuencia.
La comparación usa orden <em>lexicográfico</em>: primero se comparan los dos primeros
ítems, si son diferentes esto ya determina el resultado de la comparación; si
son iguales, se comparan los siguientes dos ítems, y así sucesivamente hasta
llegar al final de alguna de las secuencias. Si dos ítems a comparar son ambos
secuencias del mismo tipo, la comparación lexicográfica es recursiva.  Si todos
los ítems de dos secuencias resultan iguales, se considera que las secuencias
son iguales.
Si una secuencia es una subsecuencia inicial de la otra, la secuencia más corta
es la menor. El orden lexicográfico para cadenas de caracteres utiliza el orden
ASCII para caracteres individuales.  Algunos ejemplos de comparaciones entre
secuencias del mismo tipo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>              <span class="o">&lt;</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>              <span class="o">&lt;</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
<span class="s">&#39;ABC&#39;</span> <span class="o">&lt;</span> <span class="s">&#39;C&#39;</span> <span class="o">&lt;</span> <span class="s">&#39;Pascal&#39;</span> <span class="o">&lt;</span> <span class="s">&#39;Python&#39;</span>
<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>           <span class="o">&lt;</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>                 <span class="o">&lt;</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>             <span class="o">==</span> <span class="p">(</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">,</span> <span class="mf">3.0</span><span class="p">)</span>
<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="s">&#39;aa&#39;</span><span class="p">,</span> <span class="s">&#39;ab&#39;</span><span class="p">))</span>   <span class="o">&lt;</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="s">&#39;abc&#39;</span><span class="p">,</span> <span class="s">&#39;a&#39;</span><span class="p">),</span> <span class="mi">4</span><span class="p">)</span>
</pre></div>
</div>
<p>Observá que comparar objetos de diferentes tipos es legal.  El resultado es
determinístico pero arbitrario: los tipos se ordenan por su nombre.  Por lo
tanto, una lista (<tt class="docutils literal"><span class="pre">list</span></tt>) siempre evalúa como menor que una cadena
(<tt class="docutils literal"><span class="pre">string</span></tt>).</p>
<p>Los tipos numéricos diferentes se comparan a su valor numérico, o sea 0 es
igual a 0.0, etc.  No confiar demasiado en las reglas para comparar objetos de
diferentes tipos; pueden cambiar en una versión futura del lenguaje.</p>
</div>
</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
            <h3><a href="contenido.html">Contenidos</a></h3>
            <ul>
<li><a class="reference external" href="#">6. Estructuras de datos</a><ul>
<li><a class="reference external" href="#mas-sobre-listas">6.1. Más sobre listas</a><ul>
<li><a class="reference external" href="#usando-listas-como-pilas">6.1.1. Usando listas como pilas</a></li>
<li><a class="reference external" href="#usando-listas-como-colas">6.1.2. Usando listas como colas</a></li>
<li><a class="reference external" href="#herramientas-de-programacion-funcional">6.1.3. Herramientas de programación funcional</a></li>
<li><a class="reference external" href="#listas-por-comprension">6.1.4. Listas por comprensión</a></li>
<li><a class="reference external" href="#listas-por-comprension-anidadas">6.1.5. Listas por comprensión anidadas</a></li>
</ul>
</li>
<li><a class="reference external" href="#la-instruccion-del">6.2. La instrucción <tt class="docutils literal"><span class="pre">del</span></tt></a></li>
<li><a class="reference external" href="#tuplas-y-secuencias">6.3. Tuplas y secuencias</a></li>
<li><a class="reference external" href="#conjuntos">6.4. Conjuntos</a></li>
<li><a class="reference external" href="#diccionarios">6.5. Diccionarios</a></li>
<li><a class="reference external" href="#tecnicas-de-iteracion">6.6. Técnicas de iteración</a></li>
<li><a class="reference external" href="#mas-acerca-de-condiciones">6.7. Más acerca de condiciones</a></li>
<li><a class="reference external" href="#comparando-secuencias-y-otros-tipos">6.8. Comparando secuencias y otros tipos</a></li>
</ul>
</li>
</ul>

            <h4>Tema anterior</h4>
            <p class="topless"><a href="controlflow.html"
                                  title="Capítulo anterior">5. Más herramientas para control de flujo</a></p>
            <h4>Próximo tema</h4>
            <p class="topless"><a href="modules.html"
                                  title="Próximo capítulo">7. Módulos</a></p>
            <h3>Esta página</h3>
            <ul class="this-page-menu">
              <li><a href="_sources/datastructures.txt"
                     rel="nofollow">Enseñar el código</a></li>
            </ul>
          <div id="searchbox" style="display: none">
            <h3>Búsqueda rápida</h3>
              <form class="search" action="search.html" method="get">
                <input type="text" name="q" size="18" />
                <input type="submit" value="Ir a" />
                <input type="hidden" name="check_keywords" value="yes" />
                <input type="hidden" name="area" value="default" />
              </form>
              <p class="searchtip" style="font-size: 90%">
              Ingrese una palabra para buscar o un nombre de módulo, clase o función
              </p>
          </div>
          <h4><a href="/"> Volver a CdPedia </a></h4>
          <script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related">
      <h3>Navegación</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="Índice General"
             >índice</a></li>
        <li class="right" >
          <a href="modules.html" title="7. Módulos"
             >siguiente</a> |</li>
        <li class="right" >
          <a href="controlflow.html" title="5. Más herramientas para control de flujo"
             >anterior</a> |</li>
        <li><a href="contenido.html">Tutorial de Python v2.6.2 documentation</a> &raquo;</li> 
      </ul>
    </div>
    <div class="footer">
      &copy; Copyright 2009, Python Software Foundation.
      Creado con <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.6.5.
    </div>
  </body>
</html>
